
#ifndef Point_h
#define Point_h

#include <Typedef.h>
#include <Defines.h>
#include <CSharpPropertyMethods.h>

#include <System/Object.h>
#include <System/Byte.h>
#include <System/Generic/IEquatable.h>

#include "RMathHelper.h"
#include "Vector3.h"
#include "Vector4.h"

namespace Riccsson
{
	namespace Xna
	{
		namespace Framework
		{
            struct Point
				: public Riccsson::System::Object
				, public Riccsson::System::Generic::IEquatable<Point>
            {
                #pragma region Private Fields

                // TODO: Implement this.
                //private: static GC_PTR<Point> zeroPoint = new Point();

                #pragma endregion Private Fields


                #pragma region Public Fields

                public: int X;
                public: int Y;

                #pragma endregion Public Fields


                #pragma region Properties

                public: static Point& Zero;
                //{
                //    get { return zeroPoint; }
                //}

                #pragma endregion Properties


                #pragma region Constructors

                public: Point()
                {
                    this->X = 0;
                    this->Y = 0;
                }

                public: Point(int x, int y)
                {
                    this->X = x;
                    this->Y = y;
                }

                #pragma endregion Constructors


                #pragma region Public methods

                public: bool Equals(Point* other)
                {
                    return ((X == other->X) && (Y == other->Y));
                }
        
			    public: override bool Equals(Riccsson::System::Object* obj)
                {
                    return ( instanceof_const( obj, Point ) ) ? Riccsson::System::Object::Equals((Riccsson::System::Object*)obj) : false;
                }

                public: override int GetHashCode()
                {
                    return X ^ Y;
                }

			    public: override GC_PTR<Riccsson::System::string> ToString()
                {
                    //return string.Format("{{X:{0} Y:{1}}}", X, Y);
                    throw;
                }

                #pragma  endregion
            };

            bool operator ==(Point& a, Point& b);
			bool operator !=(Point& a, Point& b);
        }
    }
}

#endif

